package com.ning.reggie.controller;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ning.reggie.common.R;
import com.ning.reggie.entity.Category;
import com.ning.reggie.service.CategoryService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Slf4j
@RestController
@RequestMapping("/category")
@Api(tags="分类相关接口")
public class CategoryController {

    @Autowired
    private CategoryService categoryService;

    /**
     * 新增分类。
     *
     * @param category 包含分类信息的实体对象，从请求体中获取。
     * @return 返回包含新增结果的通用响应对象 R，泛型参数为 String。
     */
    @PostMapping
    @CacheEvict(value="CategoryCache",key="#category.createTime",allEntries=true)
    @ApiOperation(value = "新增分类")
    public R<String> save(@RequestBody Category category) {
        log.info("category:{}", category);
        // 调用分类服务类的 save 方法保存分类信息。
        categoryService.save(category);
        return R.success("新增分类成功");
    }

    /**
     * 分页查询。
     *
     * @param page     当前页码。
     * @param pageSize 每页显示的记录数。
     * @return 返回包含分页查询结果的通用响应对象 R，泛型参数为 Page（MyBatis Plus 的分页对象，包含 Category 实体）。
     */
    @GetMapping("/page")
    @Cacheable(value="CategoryCache",key="#page+'_'+#pageSize")
    @ApiOperation(value = "分页查询")
    public R<Page> page(int page, int pageSize) {
        // 分页构造器，创建一个分页对象，用于存储分页信息和查询结果。
        Page<Category> pageInfo = new Page<>(page, pageSize);
        // 条件构造器，创建一个 Lambda 查询包装器，用于构建查询条件。
        LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();
        // 添加排序条件，根据 Category 实体的 sort 属性进行升序排序。
        queryWrapper.orderByAsc(Category::getSort);

        // 分页查询，调用分类服务类的 page 方法进行分页查询，传入分页构造器和条件构造器。
        categoryService.page(pageInfo, queryWrapper);

        return R.success(pageInfo);
    }

    /**
     * 根据 id 删除分类。
     *
     * @param id 要删除的分类的唯一标识 id。
     * @return 返回包含删除结果的通用响应对象 R，泛型参数为 String。
     */
    @DeleteMapping
    @CacheEvict(value="CategoryCache",key="#id",allEntries=true)
    @ApiOperation(value = "删除分类")
    public R<String> delete(Long id) {
        log.info("删除分类，id 为：{}", id);

        // 使用分类服务类的 removeById 或 remove 方法根据 id 删除分类。
        //categoryService.removeById(id);
        categoryService.remove(id);

        return R.success("分类信息删除成功");
    }


    /**
     * 根据 id 修改分类信息。
     *
     * @param category 包含修改后分类信息的实体对象，从请求体中获取。
     * @return 返回包含修改结果的通用响应对象 R，泛型参数为 String。
     */
    @PutMapping
    @CacheEvict(value="CategoryCache",key="#category.updateTime",allEntries=true)
    @ApiOperation(value = "修改分类")
    public R<String> update(@RequestBody Category category) {
        log.info("修改分类信息：{}", category);
        // 调用分类服务类的 updateById 方法根据 id 修改分类信息。
        categoryService.updateById(category);
        return R.success("修改分类信息成功");
    }


    /**
     * 根据条件查询分类数据。
     *
     * @param category 包含查询条件的分类实体对象。
     * @return 返回包含查询结果的通用响应对象 R，泛型参数为 List<Category>（分类列表）。
     */
    @GetMapping("/list")
    @Cacheable(value="CategoryCache")
    @ApiOperation(value = "根据条件查询分类数据")
    public R<List<Category>> list(Category category) {
        // 创建条件构造器。
        LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();
        // 添加条件，如果传入的 category 对象的 type 属性不为 null，则根据 type 属性进行查询。
        queryWrapper.eq(category.getType()!= null, Category::getType, category.getType());
        // 添加排序条件，先按照 sort 属性升序排序，再按照 updateTime 属性降序排序。
        queryWrapper.orderByAsc(Category::getSort).orderByDesc(Category::getUpdateTime);

        // 调用分类服务类的 list 方法进行查询，传入条件构造器。
        List<Category> list = categoryService.list(queryWrapper);
        return R.success(list);
    }
}
